package com.example.admin.mybledemo.ota;

import java.security.SecureRandom;

import cn.com.heaton.blelibrary.ble.BleLog;

/**
 * 随机MAC地址管理器
 * 负责第一阶段生成随机MAC地址，第二阶段识别Boot模式设备
 * 
 * 基于Flutter实现移植到Java
 */
public class RandomMacManager {
    
    private static final String TAG = "RandomMacManager";
    
    private static RandomMacManager instance;
    private String randomMacString = "";
    private String originalDeviceMac = ""; // 添加原始设备MAC地址跟踪
    private SecureRandom random = new SecureRandom();
    
    private RandomMacManager() {
        // 私有构造函数
    }
    
    public static synchronized RandomMacManager getInstance() {
        if (instance == null) {
            instance = new RandomMacManager();
        }
        return instance;
    }
    
    /**
     * 设置原始设备MAC地址（第一阶段连接的设备）
     * 
     * @param deviceMac 原始设备MAC地址
     */
    public void setOriginalDeviceMac(String deviceMac) {
        this.originalDeviceMac = deviceMac;
        BleLog.d(TAG, "设置原始设备MAC地址: " + deviceMac);
    }
    
    /**
     * 获取原始设备MAC地址
     * 
     * @return 原始设备MAC地址
     */
    public String getOriginalDeviceMac() {
        return originalDeviceMac;
    }
    
    /**
     * 生成随机MAC地址字节数组
     * 使用固定MAC地址，与Flutter端iOS实现保持一致
     * 
     * @return 6字节的固定MAC地址
     */
    public byte[] generateRandomMacBytes() {
        // 使用固定MAC地址，与Flutter端iOS实现保持一致
        byte[] fixedMac = {
            (byte) 0xc2,
            (byte) 0x6d,
            (byte) 0x69,
            (byte) 0xc4,
            (byte) 0xc7,
            (byte) 0xe7
        };
        BleLog.d(TAG, "使用固定MAC地址: " + bytesToHexString(fixedMac));
        return fixedMac;
    }
    
    /**
     * 生成随机MAC地址并保存为字符串
     * 
     * @return 随机MAC地址字符串，格式为 XX:XX:XX:XX:XX:XX
     */
    public String generateAndStoreRandomMac() {
        byte[] macBytes = generateRandomMacBytes();
        
        // 转换为小端序（根据Flutter实现）
        byte[] reversedMacBytes = new byte[6];
        for (int i = 0; i < 6; i++) {
            reversedMacBytes[i] = macBytes[5 - i];
        }
        
        // 转换为字符串格式
        StringBuilder macStringBuilder = new StringBuilder();
        for (int i = 0; i < reversedMacBytes.length; i++) {
            if (i > 0) {
                macStringBuilder.append(":");
            }
            macStringBuilder.append(String.format("%02X", reversedMacBytes[i] & 0xFF));
        }
        
        randomMacString = macStringBuilder.toString();
        
        BleLog.d(TAG, "生成随机MAC地址: " + randomMacString);
        
        return randomMacString;
    }
    
    /**
     * 获取当前存储的随机MAC地址字符串
     * 
     * @return 随机MAC地址字符串
     */
    public String getRandomMacString() {
        return randomMacString;
    }
    
    /**
     * 检查设备是否为Boot模式设备（通过MAC地址或设备名匹配）
     * 
     * @param deviceAddress 设备MAC地址
     * @param deviceName 设备名称
     * @return 如果是Boot模式设备返回true，否则返回false
     */
    public boolean isBootModeDevice(String deviceAddress, String deviceName) {
        if (randomMacString.isEmpty()) {
            BleLog.d(TAG, "随机MAC地址为空，无法识别Boot设备");
            return false;
        }
        
        // 检查是否匹配随机MAC地址（Boot模式设备使用随机MAC）
        boolean randomMacMatches = deviceAddress != null && 
                                 deviceAddress.toUpperCase().equals(randomMacString.toUpperCase());
        
        // 检查设备名匹配（Boot模式设备通常名为 "ble_ota"）
        boolean nameMatches = "ble_ota".equals(deviceName);
        
        // 检查是否匹配原始MAC地址（有些设备Boot模式可能仍使用原始MAC）
        boolean originalMacMatches = deviceAddress != null && 
                                   deviceAddress.toUpperCase().equals(originalDeviceMac.toUpperCase());
        
        BleLog.d(TAG, "Boot设备检查 - 设备MAC: " + deviceAddress + 
                     ", 设备名: " + deviceName + 
                     ", 随机MAC: " + randomMacString + 
                     ", 原始MAC: " + originalDeviceMac);
        
        // 优先检查随机MAC匹配（与Flutter端逻辑一致）
        if (randomMacMatches) {
            BleLog.d(TAG, "✓ 发现Boot模式设备（随机MAC匹配）: " + deviceAddress + " (" + deviceName + ")");
            return true;
        }
        
        // 检查设备名是否为"ble_ota"
        if (nameMatches) {
            BleLog.d(TAG, "✓ 发现Boot模式设备（名称匹配）: " + deviceAddress + " (" + deviceName + ")");
            return true;
        }
        
        // 最后检查原始MAC匹配（兼容性考虑）
        if (originalMacMatches) {
            BleLog.d(TAG, "✓ 发现可能的Boot设备（原始MAC匹配）: " + deviceAddress + " (" + deviceName + ")");
            return true;
        }
        
        BleLog.d(TAG, "✗ 不是Boot模式设备: " + deviceAddress + " (" + deviceName + ")");
        return false;
    }
    
    /**
     * 获取随机MAC地址的原始字节数组（用于发送凭证数据）
     * 
     * @return 6字节的随机MAC地址（小端序）
     */
    public byte[] getRandomMacBytes() {
        if (randomMacString.isEmpty()) {
            // 如果还没有生成，先生成并存储随机MAC字符串
            generateAndStoreRandomMac();
        }
        
        // 从字符串解析MAC地址
        String[] macParts = randomMacString.split(":");
        byte[] macBytes = new byte[6];
        
        for (int i = 0; i < macParts.length; i++) {
            macBytes[i] = (byte) Integer.parseInt(macParts[i], 16);
        }
        
        return macBytes;
    }
    
    /**
     * 清除存储的随机MAC地址和原始设备MAC
     */
    public void clear() {
        randomMacString = "";
        originalDeviceMac = "";
        BleLog.d(TAG, "清除随机MAC地址和原始设备MAC");
    }
    
    /**
     * 检查是否已生成随机MAC地址
     * 
     * @return 如果已生成返回true，否则返回false
     */
    public boolean hasRandomMac() {
        return !randomMacString.isEmpty();
    }
    
    /**
     * 用于调试的方法：以十六进制格式打印MAC地址字节数组
     * 
     * @param macBytes MAC地址字节数组
     * @return 十六进制字符串表示
     */
    public static String bytesToHexString(byte[] macBytes) {
        StringBuilder hexString = new StringBuilder();
        for (byte b : macBytes) {
            hexString.append(String.format("%02X", b & 0xFF));
        }
        return hexString.toString();
    }
} 